"""
中控面板，用于实时监控和管理直播过程
"""
import json
from PyQt5.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QTabWidget, QLabel, 
    QPushButton, QMessageBox, QSplitter, QTableWidgetItem, QCheckBox
)
from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot, QTimer
from PyQt5.QtGui import QFont
import uuid
import time
import random
import os

from app.controllers.websocket_controller import WebSocketController
from app.services.service_locator import ServiceLocator
from app.services.ai_service import IAIService
from app.services.speech_service import ISpeechService
from app.services.script_service import IScriptService
from app.services.audio_service import IAudioService
from app.services.websocket_service import IWebSocketService
from app.ui.components.user_panel import UserPanel
from app.ui.components.content_panel import ContentPanel
from app.ui.modules.playlist_module import PlaylistModule
from app.ui.components.log_panel import LogPanel
from app.ui.components.status_bar import StatusBar
from app.ui.components.styled_button import StyledButton
from app.utils.logger import Logger
from app.services.config_service import IConfigService
from app.services.comment_service import ICommentService
from app.services.sync_service import ISyncService
from app.utils.speech_text_processor import SpeechTextProcessor
from app.state.app_state_manager import AppStateManager
from app.state.state_types import StateType, StateValues
from app.models.status_monitor_model import StatusMonitorModel, StatusType as MonitorStatusType

from app.models.audio_item import AudioItem
from app.utils.logger import Logger
from app.controllers.websocket_controller import WebSocketController
from app.utils.username_processor import process_username  # 导入用户名处理函数

class ControlPanel(QWidget):
    """
    中控面板，用于实时监控和管理直播过程
    """
    
    def __init__(self, parent=None):
        """
        初始化中控面板
        """
        super().__init__(parent)
        
        # 获取日志记录器
        self.logger = Logger.get_logger("control_panel")
        
        # 获取状态监控模型
        self.status_monitor = StatusMonitorModel.instance()

        # 获取WebSocket控制器
        self.websocket_controller = ServiceLocator.get(WebSocketController)
        if not self.websocket_controller:
            self.logger.warning("无法从ServiceLocator获取WebSocket控制器，尝试直接创建")
            self.websocket_controller = WebSocketController()
        
        # 获取状态管理器
        self.state_manager = ServiceLocator.get(AppStateManager)
        if not self.state_manager:
            self.logger.error("无法获取状态管理器，状态更新可能不正确")
        
        # 获取主要服务
        self.ai_service = ServiceLocator.get(IAIService)
        self.speech_service = ServiceLocator.get(ISpeechService)
        self.script_service = ServiceLocator.get(IScriptService)
        self.audio_service = ServiceLocator.get(IAudioService)
        self.websocket_service = ServiceLocator.get(IWebSocketService)
        self.config_service = ServiceLocator.get(IConfigService)
        self.comment_service = ServiceLocator.get(ICommentService)
        self.sync_service = ServiceLocator.get(ISyncService)
        
        # 初始化UI
        self._init_ui()
        
        # 注册信号处理器
        self._connect_signals()
        
        # 初始化连接状态为"未连接"
        self.update_connection_status("未连接")
        
        # 更新动态欢迎状态
        self._update_flow_welcome_status()
        
        # 初始化已处理的评论ID集合
        self.processed_comment_ids = set()
        
        # 初始化关键词和用户进入状态
        self.keyword_enabled = True
        self.user_join_enabled = True
        
        # 用户进入相关变量 - 注意：基础欢迎逻辑已被动态流量欢迎策略取代
        self._last_user_welcome_time = 0  # 上次触发用户欢迎话术的时间
        self._waiting_for_user_welcome = False  # 是否正在等待触发用户欢迎话术
        
        # 初始化播放状态
        self.is_playing = False
        
        # 初始化暂停状态
        self.is_paused = False
        
        # 添加按钮点击防抖变量
        self._last_pause_click_time = 0
        self._button_debounce_interval = 800  # 毫秒
        self._is_button_processing = False  # 标记按钮是否正在处理中
        
        self.logger.info("中控面板初始化完成")
        
    def _init_ui(self):
        """
        初始化UI
        """
        # 创建主布局
        self.layout = QVBoxLayout(self)
        self.layout.setContentsMargins(10, 10, 10, 10)
        self.layout.setSpacing(10)
        
        # 创建顶部区域（状态栏和开始按钮）
        top_widget = QWidget()
        top_layout = QHBoxLayout(top_widget)
        top_layout.setContentsMargins(0, 0, 0, 0)
        top_layout.setSpacing(10)
        
        # 创建状态栏
        self.status_bar = StatusBar()
        top_layout.addWidget(self.status_bar, 1)  # 1是伸展因子
        
        # 创建按钮区域
        control_buttons_layout = QHBoxLayout()
        control_buttons_layout.setSpacing(5)
        
        # 创建暂停/继续按钮
        self.pause_resume_button = StyledButton("暂停", button_type=StyledButton.WARNING)
        self.pause_resume_button.setMinimumSize(100, 30)
        self.pause_resume_button.clicked.connect(self._on_pause_resume_clicked)
        self.pause_resume_button.setEnabled(False)  # 初始状态为禁用
        control_buttons_layout.addWidget(self.pause_resume_button)
        
        # 创建开始按钮
        self.start_button = StyledButton("开始", button_type=StyledButton.PRIMARY)
        self.start_button.setMinimumSize(100, 30)
        self.start_button.clicked.connect(self._on_start_clicked)
        control_buttons_layout.addWidget(self.start_button)
        
        # 添加按钮区域到顶部布局
        top_layout.addLayout(control_buttons_layout)
        
        # 添加顶部区域到主布局
        self.layout.addWidget(top_widget)
        
        # 创建中间区域（用户面板、中央内容区域、播放队列）
        middle_widget = QWidget()
        middle_layout = QHBoxLayout(middle_widget)
        middle_layout.setContentsMargins(0, 0, 0, 0)
        middle_layout.setSpacing(10)
        
        # 创建用户面板
        self.user_panel = UserPanel()
        middle_layout.addWidget(self.user_panel)
        
        # 创建中央内容区域
        self.content_panel = ContentPanel()
        middle_layout.addWidget(self.content_panel, 1)  # 1是伸展因子
        
        # 创建播放队列
        self.playlist_panel = PlaylistModule()
        middle_layout.addWidget(self.playlist_panel)
        
        self.layout.addWidget(middle_widget, 1)  # 1是伸展因子
        
        # 创建日志面板
        self.log_panel = LogPanel()
        self.layout.addWidget(self.log_panel)
        
        # 在初始化完成后检查按钮状态
        QTimer.singleShot(500, self._check_button_state)
    
    def _connect_signals(self):
        """
        连接信号和槽
        """
        # 连接内容面板的消息发送信号
        self.content_panel.message_sent.connect(self._on_message_sent)
        
        # 连接内容面板的音画同步状态变化信号
        self.content_panel.sync_status_changed.connect(self._on_sync_status_changed)
        
        # 连接播放队列的队列更新信号
        self.playlist_panel.queue_updated.connect(self._on_queue_updated)
        
        # 连接播放队列的播放开始信号
        self.playlist_panel.playback_started.connect(self._on_playback_started)
        
        # 连接播放队列的播放完成信号
        self.playlist_panel.playback_completed.connect(self._on_playback_completed)
        
        # 连接WebSocket控制器的信号
        self.websocket_controller.connection_status_changed.connect(self._on_connection_changed)
        self.websocket_controller.message_received.connect(self._on_message_received)
        self.websocket_controller.error_occurred.connect(self._on_websocket_error)
        
        # 连接用户面板的AI分析请求信号
        self.user_panel.ai_analyze_requested.connect(self._on_ai_analyze_requested)
        
        # 添加AI服务的评论分析完成事件监听
        if self.ai_service:
            self.ai_service.add_listener("comment_analyzed", self._on_comment_analyzed)
            self.logger.info("已连接AI服务的评论分析完成事件")
        else:
            self.logger.warning("无法连接AI服务的评论分析完成事件: AI服务不可用")
        
        # 添加评论服务的用户加入事件监听
        if self.comment_service:
            self.comment_service.add_listener("user_joined", self._on_user_joined)
            self.logger.info("已连接评论服务的用户加入事件")
            
            # 添加评论事件监听（只保留comment_added，移除comment_processed）
            self.comment_service.add_listener("comment_added", self._on_comment_added)
            self.logger.info("已连接评论服务的评论事件")
        else:
            self.logger.warning("无法连接评论服务的用户加入事件: 评论服务不可用")
        
        # 从配置服务获取开关状态，而不是在UI中设置
        if self.config_service:
            self.keyword_enabled = self.config_service.get("keyword.enabled", True)
            self.user_join_enabled = self.config_service.get("user_join.enabled", True)
        else:
            # 默认值
            self.keyword_enabled = True
            self.user_join_enabled = True
        
        # 连接状态监控模型的状态变化信号
        if self.status_monitor:
            self.status_monitor.add_listener(MonitorStatusType.AUDIO_SERVICE, self._check_button_state)
            self.status_monitor.add_listener(MonitorStatusType.AI_SERVICE, self._check_button_state)
            
        # 添加音频服务的"播放完当前音频后暂停"事件监听
        audio_service = ServiceLocator.get(IAudioService)
        if audio_service:
            audio_service.add_listener("audio_will_pause_after_current", self._on_audio_will_pause_after_current)
            self.logger.info("已连接音频服务的'播放完当前音频后暂停'事件")
    
    @pyqtSlot(dict)
    def _on_message_received(self, message):
        """
        接收到消息事件处理
        
        @param message: 接收到的消息
        """
        try:
            # 根据消息类型处理
            msg_type = message.get('type', 'unknown')
            
            # 获取用户名 - 支持多种字段名
            username = message.get('username', message.get('user_name', message.get('nickname', '未知用户')))
            
            # 记录原始消息
            self.logger.debug(f"[Socket数据] 收到原始消息: {message}")
            
            # 根据消息类型添加到相应面板
            if msg_type == 'comment':
                content = message.get('content', '')
                # 调用user_panel的add_interaction方法，非礼物消息
                self.user_panel.add_interaction(username, content, is_gift=False)
                self.logger.info(f"收到评论消息: 用户={username}, 内容={content}")
                self.log_panel.add_playback_log(f"收到评论: {username} - {content}")
                
                # 检查是否匹配关键词话术
                # 注意：关键词匹配和AI回复的主要逻辑已移至CommentService中处理
                # 这里只负责UI处理和触发关键词话术播放
                self._process_keyword_speech(username, content)
            elif msg_type == 'join':
                count = message.get('count', 1)
                # 调用user_panel的add_user_join方法
                self.user_panel.add_user_join(username, count)
                self.logger.info(f"用户加入直播间: 用户={username}, 人数={count}")
                self.log_panel.add_playback_log(f"收到用户加入: {username}")
                
                # 处理用户进入欢迎话术
                self._process_user_join(username, count)
            elif msg_type == 'gift':
                # 处理礼物消息 - 直接显示content内容
                content = message.get('content', '')
                # 调用user_panel的add_interaction方法，传递is_gift=True
                self.user_panel.add_interaction(username, content, is_gift=True)
                self.logger.info(f"收到礼物消息: 用户={username}, 内容={content}")
                self.log_panel.add_playback_log(f"收到礼物: {username} - {content}")
            else:
                # 未知类型，打印调试信息
                self.logger.warning(f"收到未知类型消息: {message}")
                self.log_panel.add_playback_log(f"收到未知类型消息: {str(message)[:100]}...")
        except Exception as e:
            self.logger.error(f"处理消息事件失败: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
    
    @pyqtSlot(str)
    def _on_connection_changed(self, status):
        """
        处理连接状态变化
        
        @param status: 连接状态字符串
        """
        self.update_connection_status(status)
        
        # 更新用户面板状态
        connected = (status == "已连接")
        self.user_panel.on_connection_changed(connected)
        
        # 记录连接状态变化到日志面板
        self.log_panel.add_playback_log(f"WebSocket连接状态: {status}")
    
    @pyqtSlot(str)
    def _on_websocket_error(self, error):
        """
        处理WebSocket错误
        
        @param error: 错误信息
        """
        # 记录错误到日志面板
        self.log_panel.add_playback_log(f"WebSocket错误: {error}")
        
        # 更新连接状态
        self.update_connection_status("连接错误")
        
        self.logger.error(f"WebSocket错误: {error}")
    
    @pyqtSlot(dict)
    def _on_ai_analyze_requested(self, data):
        """
        处理AI分析请求
        
        @param data: 要分析的数据
        """
        # 这里添加AI分析请求处理逻辑
        self.log_panel.add_ai_log(f"请求AI分析: {data.get('user_name', '未知用户')} - {data.get('content', '无内容')}")
        
        self.logger.debug(f"请求AI分析: {data}")
    
    def _on_message_sent(self, message):
        """
        处理消息发送
        
        @param message: 要发送的消息
        """
        # 直接使用self.playlist_panel
        if hasattr(self, 'playlist_panel') and self.playlist_panel:
            # 添加临时话术
            self.playlist_panel.add_temporary_speech("插播", message)
            
            # 手动刷新播放队列表格
            if hasattr(self.playlist_panel, 'refresh_playlist'):
                self.playlist_panel.refresh_playlist()
                
            self.log_panel.add_playback_log(f"已添加插播消息到队列: {message}")
            self.logger.info(f"已添加插播消息到队列: {message}")
        else:
            # 如果没有播放队列面板，则记录警告
            self.log_panel.add_playback_log(f"消息发送功能未实现: {message}")
            self.logger.warning(f"消息发送功能未实现: {message}")
    
    def _on_sync_status_changed(self, enabled):
        """
        处理音画同步状态变化
        
        @param enabled: 是否启用音画同步
        """
        # 更新状态栏的音画同步状态
        status = "已开启" if enabled else "未开启"
        self.status_bar.update_sync_status(status)
        
        # 记录日志
        self.log_panel.add_playback_log(f"音画同步{status}")
        
        # 获取音画同步服务
        sync_service = ServiceLocator.get(ISyncService)
        if sync_service:
            # 更新服务状态
            sync_service.enable_sync(enabled)
            
            # 更新ContentPanel中的SyncModule状态
            if hasattr(self.content_panel, 'sync_tab') and hasattr(self.content_panel.sync_tab, 'update_sync_status'):
                self.content_panel.sync_tab.update_sync_status(enabled)
    
    def _on_queue_updated(self, queue):
        """
        处理队列更新事件
        
        @param queue: 更新后的队列
        """
        # 不再更新状态栏，仅记录日志，避免显示"XX个项目"
        queue_length = len(queue)
        # self.logger.info(f"队列更新: {queue_length}个项目")
        
        # 不再调用update_playback_status以防止状态混淆
        # self.status_bar.update_playback_status(f"{queue_length}个项目")
    
    def _on_playback_started(self, audio_item):
        """
        处理播放开始事件
        
        @param audio_item: 开始播放的音频项
        """
        # 更新我们的播放状态记录
        self.is_playing = True
        self.is_paused = False
        
        # 更新按钮状态
        self.pause_resume_button.setText("暂停")
        self.pause_resume_button.setEnabled(True)
        
        # 添加播放日志
        if hasattr(self, 'log_panel') and self.log_panel:
            self.log_panel.add_playback_log(f"开始播放: {audio_item.title}")
            
        # 设置播放状态为PLAYING
        if self.state_manager:
            self.logger.info("设置播放状态为PLAYING")
            self.state_manager.set_state(StateType.PLAYBACK, StateValues.PLAYING)
    
    def _on_playback_completed(self, audio_item):
        """
        处理播放完成事件
        
        @param audio_item: 完成播放的音频项
        """
        self.logger.info(f"播放完成: {audio_item.title if audio_item else 'Unknown'}")
        
        # 检查播放队列状态，如果队列为空，则更新按钮状态
        audio_service = ServiceLocator.get(IAudioService)
        if audio_service:
            queue = audio_service.get_queue()
            if not queue:
                self.logger.info("播放队列为空，重置播放状态")
                
                # 更新按钮状态和文本
                self.start_button.setText("开始")
                self.start_button.setStyleSheet("")  # 恢复默认样式
                
                # 禁用暂停/继续按钮
                self.pause_resume_button.setEnabled(False)
                self.pause_resume_button.setText("暂停")
                self.is_paused = False
                
                # 更新播放状态
                self.is_playing = False
                
                # 设置播放状态为READY
                if self.state_manager:
                    self.logger.info("设置播放状态为READY")
                    self.state_manager.set_state(StateType.PLAYBACK, StateValues.READY)
    
    def _on_comment_analyzed(self, event):
        """
        处理评论分析事件
        
        @param event: 事件对象
        """
        try:
            # 获取事件数据
            data = event.data
            self.logger.info(f"收到评论分析事件: {data}")
            
            # 获取评论ID和回复
            comment_id = data.get("comment_id", "")
            
            # 检查是否已处理过该评论ID
            if comment_id in self.processed_comment_ids:
                self.logger.info(f"评论ID已处理过，跳过: {comment_id}")
                return
                
            # 将评论ID添加到已处理集合
            self.processed_comment_ids.add(comment_id)
            
            reply = data.get("reply", "")
            source = data.get("source", "unknown")
            
            # 确保reply是字符串类型
            if not isinstance(reply, str):
                reply = str(reply)
            
            self.logger.info(f"评论分析结果: ID={comment_id}, 来源={source}, 回复长度={len(reply)}")
            
            # 检查回复是否包含错误信息
            if isinstance(reply, str) and ("error" in reply.lower() or "错误" in reply):
                self.logger.warning(f"回复包含错误信息: {reply}")
                # 处理错误回复，确保UI不会崩溃
                if source == "script":
                    script_id = data.get("script_id", "")
                    self.logger.info(f"使用脚本回复(错误): ID={comment_id}, 脚本ID={script_id}")
                    self.log_panel.add_ai_log(f"脚本回复(错误) (ID: {script_id}): {reply}")
                else:
                    self.logger.info(f"使用AI回复(错误): ID={comment_id}")
                    self.log_panel.add_ai_log(f"AI回复(错误): {reply}")
                    
                    # 将AI回复添加到插播队列中
                    if hasattr(self, 'playlist_panel') and self.playlist_panel:
                        # 添加临时话术
                        self.playlist_panel.add_temporary_speech("AI回复", reply)
                        
                        # 手动刷新播放队列表格
                        if hasattr(self.playlist_panel, 'refresh_playlist'):
                            self.playlist_panel.refresh_playlist()
                            
                        # 添加到插播记录列表
                        self.add_playback_log(f"AI回复: {reply}")
                        self.log_panel.add_playback_log(f"已添加AI回复到插播队列: {reply}")
                        self.logger.info(f"已添加AI回复到插播队列: {reply}")
                        
                        # 添加到content_panel的插播记录列表
                        if hasattr(self, 'content_panel') and hasattr(self.content_panel, '_add_to_insert_list'):
                            self.content_panel._add_to_insert_list("AI回复", reply)
                    else:
                        # 如果没有播放队列面板，则记录警告
                        self.logger.warning("无法添加AI回复到插播队列：播放队列面板不可用")
            else:
                # 记录日志
                if source == "script":
                    script_id = data.get("script_id", "")
                    self.logger.info(f"使用脚本回复: ID={comment_id}, 脚本ID={script_id}")
                    self.log_panel.add_ai_log(f"脚本回复 (ID: {script_id}): {reply}")
                else:
                    self.logger.info(f"使用AI回复: ID={comment_id}")
                    self.log_panel.add_ai_log(f"AI回复: {reply}")
                    
                    # 将AI回复添加到插播队列中
                    if hasattr(self, 'playlist_panel') and self.playlist_panel:
                        # 添加临时话术
                        self.playlist_panel.add_temporary_speech("AI回复", reply)
                        
                        # 手动刷新播放队列表格
                        if hasattr(self.playlist_panel, 'refresh_playlist'):
                            self.playlist_panel.refresh_playlist()
                            
                        # 添加到插播记录列表
                        self.add_playback_log(f"AI回复: {reply}")
                        self.log_panel.add_playback_log(f"已添加AI回复到插播队列: {reply}")
                        self.logger.info(f"已添加AI回复到插播队列: {reply}")
                        
                        # 添加到content_panel的插播记录列表
                        if hasattr(self, 'content_panel') and hasattr(self.content_panel, '_add_to_insert_list'):
                            self.content_panel._add_to_insert_list("AI回复", reply)
                    else:
                        # 如果没有播放队列面板，则记录警告
                        self.logger.warning("无法添加AI回复到插播队列：播放队列面板不可用")
            
            self.logger.info(f"评论分析事件处理完成: ID={comment_id}")
        except Exception as e:
            self.logger.error(f"处理评论分析事件时出错: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
    
    def _on_user_joined(self, event):
        """
        处理用户进入事件
        
        @param event: 事件对象，包含用户进入信息
        """
        try:
            # 获取事件数据
            data = event.data
            self.logger.info(f"收到用户进入事件: {data}")
            
            # 获取用户名和平台信息
            username = data.get("user_name", "")
            platform = data.get("platform", "未知平台")
            timestamp = data.get("timestamp", "")
            
            # 记录日志
            self.logger.info(f"用户 {username} 从 {platform} 进入直播间，时间：{timestamp}")
            
            # 更新用户面板
            if hasattr(self, 'user_panel') and self.user_panel:
                count = 1  # 默认人数为1
                self.user_panel.add_user_join(username, count)
                self.logger.debug(f"已更新用户面板，显示用户 {username} 进入")
            
            # 处理用户进入事件
            self._process_user_join(username, 1)
            
            # 记录到日志面板
            if hasattr(self, 'log_panel') and self.log_panel:
                self.log_panel.add_playback_log(f"用户进入: {username} (来自 {platform})")
                
            self.logger.info(f"用户进入事件处理完成: {username}")
        except Exception as e:
            self.logger.error(f"处理用户进入事件时出错: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
    
    def _on_comment_added(self, event):
        """
        处理评论添加事件
        
        @param event: 事件对象，包含评论信息
        """
        try:
            # 获取事件数据
            comment = event.data
            self.logger.info(f"收到评论添加事件: {comment}")
            
            # 检查是否是Comment对象
            if hasattr(comment, 'user_name') and hasattr(comment, 'content'):
                # 直接从Comment对象获取属性
                username = comment.user_name
                content = comment.content
                platform = getattr(comment, 'platform', "未知平台")
                
                # 检查是否是礼物消息
                is_gift = False
                if hasattr(comment, 'metadata') and isinstance(comment.metadata, dict):
                    metadata = comment.metadata
                    msg_type = metadata.get('type', '')
                    if msg_type == 'gift':
                        is_gift = True
                        gift_name = metadata.get('gift_name', '未知礼物')
                        gift_count = metadata.get('gift_count', 1)
                        self.logger.info(f"识别为礼物消息: 用户={username}, 礼物={gift_name}, 数量={gift_count}")
                        
                        # 可以选择修改显示内容
                        if not content:
                            content = f"赠送 {gift_name} x{gift_count}"
                
                # 记录日志
                if is_gift:
                    self.logger.info(f"收到礼物消息: 用户={username}, 内容={content}, 平台={platform}")
                else:
                    self.logger.info(f"收到评论消息: 用户={username}, 内容={content}, 平台={platform}")
                
                # 更新用户面板
                if hasattr(self, 'user_panel') and self.user_panel:
                    # 调用user_panel的add_interaction方法
                    self.user_panel.add_interaction(username, content, is_gift=is_gift)
                    self.logger.debug(f"已更新用户面板，显示{'礼物' if is_gift else '评论'}: {username} - {content}")
                
                # 记录到日志面板
                if hasattr(self, 'log_panel') and self.log_panel:
                    if is_gift:
                        self.log_panel.add_playback_log(f"收到礼物: {username} - {content}")
                    else:
                        self.log_panel.add_playback_log(f"收到评论: {username} - {content}")
                    
                # 检查是否匹配关键词话术
                if not is_gift:  # 只对评论进行关键词匹配
                    self._process_keyword_speech(username, content)
                
                self.logger.info(f"评论添加事件处理完成: {username}")
            else:
                # 尝试作为字典处理
                data = comment
                if isinstance(data, dict):
                    username = data.get("user_name", "")
                    content = data.get("content", "")
                    platform = data.get("platform", "未知平台")
                    
                    # 检查是否是礼物消息
                    is_gift = False
                    metadata = data.get("metadata", {})
                    if metadata and isinstance(metadata, dict):
                        msg_type = metadata.get("type", "")
                        if msg_type == "gift":
                            is_gift = True
                            gift_name = metadata.get("gift_name", "未知礼物")
                            gift_count = metadata.get("gift_count", 1)
                            self.logger.info(f"识别为礼物消息: 用户={username}, 礼物={gift_name}, 数量={gift_count}")
                            
                            # 可以选择修改显示内容
                            if not content:
                                content = f"赠送 {gift_name} x{gift_count}"
                    
                    # 记录日志
                    if is_gift:
                        self.logger.info(f"收到礼物消息: 用户={username}, 内容={content}, 平台={platform}")
                    else:
                        self.logger.info(f"收到评论消息: 用户={username}, 内容={content}, 平台={platform}")
                    
                    # 更新用户面板
                    if hasattr(self, 'user_panel') and self.user_panel:
                        # 调用user_panel的add_interaction方法
                        self.user_panel.add_interaction(username, content, is_gift=is_gift)
                        self.logger.debug(f"已更新用户面板，显示{'礼物' if is_gift else '评论'}: {username} - {content}")
                    
                    # 记录到日志面板
                    if hasattr(self, 'log_panel') and self.log_panel:
                        if is_gift:
                            self.log_panel.add_playback_log(f"收到礼物: {username} - {content}")
                        else:
                            self.log_panel.add_playback_log(f"收到评论: {username} - {content}")
                        
                    # 检查是否匹配关键词话术
                    if not is_gift:  # 只对评论进行关键词匹配
                        self._process_keyword_speech(username, content)
                    
                    self.logger.info(f"评论添加事件处理完成(字典模式): {username}")
                else:
                    self.logger.warning(f"收到的评论添加事件数据格式不支持: {comment}")
        except Exception as e:
            self.logger.error(f"处理评论添加事件时出错: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
    
    def _process_user_join(self, username, count):
        """
        处理用户进入事件，但不再触发欢迎话术
        
        @param username: 用户名
        @param count: 人数
        """
        # 基础欢迎逻辑已被新的动态流量欢迎策略取代
        self.logger.info(f"用户 {username} 进入直播间，基础欢迎已被动态流量欢迎策略取代")
        return
    
    def _process_keyword_speech(self, username, content):
        """
        处理关键词话术
        
        @param username: 用户名
        @param content: 内容
        """
        try:
            # 检查关键词功能是否启用
            config_service = ServiceLocator.get(IConfigService)
            if config_service:
                keyword_enabled = config_service.get("keyword.enabled", False)
                if not keyword_enabled:
                    self.logger.debug("关键词触发功能已禁用，跳过处理")
                    return
                    
                self.logger.debug("关键词触发功能已启用，开始处理")
            else:
                self.logger.warning("无法获取配置服务，无法检查关键词触发功能状态")
                return
                
            # 获取音频服务
            audio_service = ServiceLocator.get(IAudioService)
            if not audio_service:
                self.logger.warning("无法获取音频服务，无法处理关键词话术")
                return
                
            # 检查是否有关键词话术管理器
            if not hasattr(audio_service, 'keyword_speech_manager') or not audio_service.keyword_speech_manager:
                self.logger.warning("关键词话术管理器不可用，尝试重新初始化")
                # 尝试重新初始化关键词话术管理器
                if config_service:
                    config_path = config_service.get("app.config_path", "")
                    if config_path:
                        try:
                            # 配置音频服务，重新初始化关键词话术管理器
                            self.logger.info(f"尝试重新初始化关键词话术管理器，配置路径: {config_path}")
                            
                            # 确保keyword.enabled设置为True，这样音频服务才会初始化关键词管理器
                            config_service.set("keyword.enabled", True)
                            config_service.save_config()
                            
                            # 重新配置音频服务
                            audio_service.configure({"config_path": config_path})
                            
                            # 再次检查关键词话术管理器是否可用
                            if not hasattr(audio_service, 'keyword_speech_manager') or not audio_service.keyword_speech_manager:
                                self.logger.error("重新初始化关键词话术管理器失败")
                                return
                            else:
                                self.logger.info("关键词话术管理器重新初始化成功")
                        except Exception as e:
                            self.logger.error(f"重新初始化关键词话术管理器出错: {str(e)}")
                            import traceback
                            self.logger.error(traceback.format_exc())
                            return
                    else:
                        self.logger.warning("配置路径为空，无法初始化关键词话术管理器")
                        return
                else:
                    return
            
            # 查找匹配的关键词
            keyword, file_name = audio_service.keyword_speech_manager.find_matching_keyword(content)
            if not keyword or not file_name:
                self.logger.debug(f"未找到匹配的关键词: {content[:30]}...")
                return
                
            self.logger.info(f"评论匹配到关键词: {keyword}, 文件: {file_name}")
            
            # 获取随机话术
            speech = audio_service.keyword_speech_manager.get_random_speech(file_name)
            if not speech:
                self.logger.warning(f"获取关键词话术失败: {file_name}")
                return
                
            # 变量替换处理
            speech = self._replace_variables(speech, username, content)
            self.logger.info(f"处理后的关键词话术: {speech[:50]}...")
            
            # 添加到插播记录
            if hasattr(self, 'content_panel') and hasattr(self.content_panel, '_add_to_insert_list'):
                self.content_panel._add_to_insert_list(f"关键词:{keyword}", speech)
                self.logger.debug(f"已添加到插播记录: 关键词:{keyword} - {speech[:30]}...")
            
            # 添加到播放队列
            if hasattr(self, 'playlist_panel') and self.playlist_panel:
                self.playlist_panel.add_temporary_speech(f"关键词:{keyword}", speech, file_name=file_name)
                
                # 刷新播放队列表格
                if hasattr(self.playlist_panel, 'refresh_playlist'):
                    self.playlist_panel.refresh_playlist()
                    
                self.logger.info(f"已添加关键词话术到播放队列: {speech[:50]}...")
                self.log_panel.add_playback_log(f"已添加关键词话术[{keyword}]到播放队列: {speech[:30]}...")
            else:
                self.logger.warning("播放队列面板不可用，无法添加关键词话术")
            
        except Exception as e:
            self.logger.error(f"处理关键词话术失败: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
            
    def _replace_variables(self, text, username, content):
        """
        替换话术中的变量
        
        @param text: 原始话术文本
        @param username: 用户名
        @param content: 评论内容
        @return: 替换后的文本
        """
        from datetime import datetime
        
        try:
            # 处理用户名
            processed_username = process_username(username)
            self.logger.debug(f"用户名处理: 原始='{username}', 处理后='{processed_username}'")
            
            variables = {
                "{用户名}": processed_username,
                "{评论}": content,
                "{时间}": datetime.now().strftime("%H:%M"),
                "{日期}": datetime.now().strftime("%Y-%m-%d"),
            }
            
            result = text
            for var, value in variables.items():
                result = result.replace(var, str(value))
                
            return result
        except Exception as e:
            self.logger.error(f"替换变量失败: {str(e)}")
            return text
    
    def _on_welcome_speech_completed(self, text, file_path):
        """
        欢迎话术合成完成回调（已禁用）
        
        @param text: 话术文本
        @param file_path: 语音文件路径
        """
        # 基础欢迎逻辑已被新的动态流量欢迎策略取代
        self.logger.info(f"欢迎话术回调已禁用，当前使用动态流量欢迎策略")
        return
    
    def _update_flow_welcome_status(self):
        """
        更新动态欢迎状态显示
        """
        if not self.config_service:
            self.logger.warning("无法获取配置服务，跳过状态更新")
            return
            
        try:
            # 获取动态欢迎配置
            enabled = self.config_service.get("flow_welcome.enabled", False)
            period = self.config_service.get("flow_welcome.period", 30)
            low_threshold = self.config_service.get("flow_welcome.low_threshold", 10)
            high_threshold = self.config_service.get("flow_welcome.high_threshold", 50)
            
            self.logger.debug(f"动态欢迎配置: 启用={enabled}, 周期={period}, 低阈值={low_threshold}, 高阈值={high_threshold}")
            
            # 构建状态显示文本
            status_text = f"{low_threshold}-{high_threshold}人/{period}秒"
            
            # 根据启用状态添加前缀
            if not enabled:
                status_text = f"disabled:{status_text}"
                self.logger.debug(f"动态欢迎已禁用，状态文本: {status_text}")
            else:
                self.logger.debug(f"动态欢迎已启用，状态文本: {status_text}")
                
            # 更新状态栏显示
            if hasattr(self, 'status_bar') and self.status_bar:
                self.logger.debug(f"开始更新状态栏显示: {status_text}")
                self.status_bar.update_user_join_status(status_text)
                self.logger.debug(f"已发送状态更新到状态栏: {status_text} (启用={enabled})")
            else:
                self.logger.warning("状态栏组件不可用")
                
        except Exception as e:
            self.logger.error(f"更新动态欢迎状态失败: {e}")
            import traceback
            self.logger.error(traceback.format_exc())
            
    def _on_flow_welcome_enabled_changed(self, state):
        """
        流量欢迎功能开关状态改变事件处理
        
        @param state: 开关状态
        """
        enabled = state == Qt.Checked
        self.logger.debug(f"动态欢迎开关状态改变: {enabled}")
        
        # 先发送配置更新信号
        self.config_updated.emit("flow_welcome.enabled", enabled)
        self.logger.info(f"动态流量欢迎功能已{'启用' if enabled else '禁用'}")
        
        # 立即更新一次状态
        self._update_flow_welcome_status()
        
        # 再次延迟更新以确保配置已完全保存
        QTimer.singleShot(500, self._update_flow_welcome_status)
        
    def _update_flow_welcome_config(self):
        """
        更新流量欢迎配置
        """
        try:
            # 获取统计周期
            period = int(self.flow_period_input.text())
            self.config_updated.emit("flow_welcome.period", period)
            
            # 获取低流量阈值
            low_threshold = int(self.low_flow_threshold_input.text())
            self.config_updated.emit("flow_welcome.low_threshold", low_threshold)
            
            # 获取高流量阈值
            high_threshold = int(self.high_flow_threshold_input.text())
            self.config_updated.emit("flow_welcome.high_threshold", high_threshold)
            
            self.logger.debug(f"流量欢迎配置已更新: 周期={period}秒, 低流量上限={low_threshold}, 高流量下限={high_threshold}")
            
            # 立即更新状态显示
            self._update_flow_welcome_status()
            
            # 延迟500ms后再次更新状态，确保配置已完全保存和应用
            QTimer.singleShot(500, self._update_flow_welcome_status)
            
        except ValueError:
            self.logger.warning("流量欢迎配置更新失败，请检查输入值")
    
    def _check_button_state(self, *args):
        """
        检查并更新开始按钮的状态
        可接受可选参数以便直接用作状态变化的回调
        """
        if not self.status_monitor:
            self.logger.warning("状态监控模型不可用，无法检查服务状态")
            self.start_button.setEnabled(False)
            return
        
        audio_service_status = self.status_monitor.get_state(MonitorStatusType.AUDIO_SERVICE)
        ai_service_status = self.status_monitor.get_state(MonitorStatusType.AI_SERVICE)
        
        # 只有当音频服务和AI服务都连接时，才启用开始按钮
        if audio_service_status == "已连接" and ai_service_status == "已连接":
            self.start_button.setEnabled(True)
            self.logger.debug("服务状态正常，开始按钮已启用")
        else:
            self.start_button.setEnabled(False)
            self.logger.debug(f"服务状态异常，开始按钮已禁用 (音频服务: {audio_service_status}, AI服务: {ai_service_status})")
        
    def _on_pause_resume_clicked(self):
        """
        处理暂停/继续按钮点击事件
        """
        # 获取当前时间（毫秒）
        current_time = int(time.time() * 1000)
        
        # 防抖动检查：如果两次点击间隔太短，则忽略
        if current_time - self._last_pause_click_time < self._button_debounce_interval:
            self.logger.debug(f"忽略过快的按钮点击，间隔: {current_time - self._last_pause_click_time}ms")
            return
            
        # 如果按钮已经在处理中，则忽略新的点击
        if self._is_button_processing:
            self.logger.debug("按钮正在处理中，忽略新的点击")
            return
            
        # 更新最后点击时间并设置处理标志
        self._last_pause_click_time = current_time
        self._is_button_processing = True
        
        # 暂时禁用按钮，防止连续点击
        self.pause_resume_button.setEnabled(False)
        
        self.logger.info("暂停/继续按钮被点击")
        
        # 获取音频服务
        audio_service = ServiceLocator.get(IAudioService)
        if not audio_service:
            self.logger.error("无法获取音频服务")
            self._reset_button_state()
            return
        
        try:
            # 根据当前状态切换
            if self.is_paused:
                # 当前是暂停状态，需要继续播放
                self.logger.info("恢复播放")
                
                # 显示处理中状态
                self.pause_resume_button.setText("处理中...")
                
                success = audio_service.resume_playback()
                if success:
                    self.is_paused = False
                    self.pause_resume_button.setText("暂停")
                    self.pause_resume_button.setStyleSheet("")  # 恢复默认样式
                    
                    # 设置播放状态为PLAYING
                    if self.state_manager:
                        self.logger.info("设置播放状态为PLAYING")
                        self.state_manager.set_state(StateType.PLAYBACK, StateValues.PLAYING)
                        
                    # 添加日志记录
                    if hasattr(self, 'log_panel') and self.log_panel:
                        self.log_panel.add_playback_log("已恢复播放")
                else:
                    self.logger.warning("恢复播放失败")
                    
                    # 获取当前播放队列
                    queue = audio_service.get_queue()
                    
                    # 如果队列为空且没有正在播放的项目，重置状态为非暂停
                    if not queue:
                        self.is_paused = False
                        self.pause_resume_button.setText("暂停")
                        
                        # 添加日志记录
                        if hasattr(self, 'log_panel') and self.log_panel:
                            self.log_panel.add_playback_log("播放队列为空，已重置播放状态")
                    else:
                        # 如果队列不为空但恢复失败，尝试播放队列中的下一项
                        self.logger.info("尝试播放队列中的下一项")
                        if audio_service.start_playback():
                            self.is_paused = False
                            self.pause_resume_button.setText("暂停")
                            
                            # 添加日志记录
                            if hasattr(self, 'log_panel') and self.log_panel:
                                self.log_panel.add_playback_log("已开始播放队列中的下一项")
                        else:
                            # 显示错误消息
                            QMessageBox.warning(self, "恢复播放失败", "无法恢复播放，请检查日志了解详情")
            else:
                # 当前是播放状态，需要暂停
                # 默认使用"播放完当前音频后暂停"模式
                self.logger.info("暂停播放（播放完当前音频后暂停）")
                
                # 显示处理中状态
                self.pause_resume_button.setText("设置中...")
                
                success = audio_service.pause_playback(after_current=True)
                if success:
                    self.is_paused = True
                    self.pause_resume_button.setText("继续")
                    self.pause_resume_button.setStyleSheet("background-color: #4CAF50; color: white;")  # 设置绿色背景
                    
                    # 当设置为播放完当前后暂停时，不立即更改状态，会在播放完成后更改
                    # 仅显示UI按钮变化提示用户已设置暂停
                    self.logger.info("已设置播放完当前音频后暂停")
                    
                    # 添加日志记录
                    if hasattr(self, 'log_panel') and self.log_panel:
                        self.log_panel.add_playback_log("已设置播放完当前音频后暂停")
                else:
                    self.logger.warning("暂停播放失败")
                    
        except Exception as e:
            self.logger.error(f"暂停/继续操作发生异常: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
            
            # 显示错误消息
            QMessageBox.critical(self, "操作失败", f"处理暂停/继续操作时发生错误: {str(e)}")
        finally:
            # 重置按钮处理状态
            self._reset_button_state()
    
    def _reset_button_state(self):
        """重置按钮状态，解除处理中状态和启用按钮"""
        self._is_button_processing = False
        self.pause_resume_button.setEnabled(True)
        
        # 确保按钮文本与状态一致
        if self.is_paused:
            self.pause_resume_button.setText("继续")
            self.pause_resume_button.setStyleSheet("background-color: #4CAF50; color: white;")  # 设置绿色背景
        else:
            self.pause_resume_button.setText("暂停")
            self.pause_resume_button.setStyleSheet("")  # 恢复默认样式
    
    def _on_start_clicked(self):
        """
        处理开始按钮点击事件
        """
        self.logger.info("开始/停止按钮被点击")
        
        # 如果当前正在播放，则停止播放
        if self.is_playing:
            self.logger.info("停止播放")
            
            # 获取音频服务
            audio_service = ServiceLocator.get(IAudioService)
            if audio_service:
                # 停止当前播放
                audio_service.stop_playback()
                # 清空播放队列
                audio_service.clear_queue()
            
            # 停止音频生成
            playlist_module = None
            for widget in self.findChildren(QWidget):
                if isinstance(widget, PlaylistModule):
                    playlist_module = widget
                    break
            
            if playlist_module:
                playlist_module.stop_generation()
            
            # 更新按钮状态和文本
            self.start_button.setText("开始")
            self.start_button.setStyleSheet("")  # 恢复默认样式
            
            # 禁用暂停/继续按钮
            self.pause_resume_button.setEnabled(False)
            self.pause_resume_button.setText("暂停")
            self.is_paused = False
            
            # 更新播放状态
            self.is_playing = False
            
            # 设置播放状态为READY
            if self.state_manager:
                self.logger.info("设置播放状态为READY")
                self.state_manager.set_state(StateType.PLAYBACK, StateValues.READY)
            
            # 刷新播放列表
            if hasattr(self, 'playlist_panel'):
                # 调用刷新全部话术的功能
                self.playlist_panel.reload_all_speeches()
                # 刷新播放列表显示
                self.playlist_panel.refresh_playlist()
            
            return
            
        # 检查音频服务和AI服务的状态
        if self.status_monitor:
            audio_service_status = self.status_monitor.get_state(MonitorStatusType.AUDIO_SERVICE)
            ai_service_status = self.status_monitor.get_state(MonitorStatusType.AI_SERVICE)
            
            if audio_service_status != "已连接":
                self.logger.warning(f"音频服务未连接，当前状态: {audio_service_status}")
                QMessageBox.warning(self, "无法开始", "音频服务未连接，请确保音频服务已连接后再试。")
                return
            
            if ai_service_status != "已连接":
                self.logger.warning(f"AI服务未连接，当前状态: {ai_service_status}")
                QMessageBox.warning(self, "无法开始", "AI服务未连接，请确保AI服务已连接后再试。")
                return
        else:
            self.logger.warning("状态监控模型不可用，无法检查服务状态")
        
        # 设置播放状态为PLAYING
        if self.state_manager:
            self.logger.info("设置播放状态为PLAYING")
            self.state_manager.set_state(StateType.PLAYBACK, StateValues.PLAYING)
        
        # 获取音频服务
        audio_service = ServiceLocator.get(IAudioService)
        if not audio_service:
            self.logger.error("无法获取音频服务")
            return
        
        # 检查音频队列是否为空，如果为空，增加一个主话术
        queue = audio_service.get_queue()
        if not queue:
            self._add_main_speech()
            
        # 搜索 PlaylistModule 实例
        playlist_module = None
        for widget in self.findChildren(QWidget):
            if isinstance(widget, PlaylistModule):
                playlist_module = widget
                break
                
        # 更新按钮状态和文本
        self.start_button.setText("停止")
        self.start_button.setStyleSheet("background-color: #ff4d4d; color: white;")  # 设置红色背景
        
        # 启用暂停/继续按钮
        self.pause_resume_button.setEnabled(True)
        self.pause_resume_button.setText("暂停")
        self.is_paused = False
        
        # 更新播放状态
        self.is_playing = True
        
        self.logger.info("开始播放")
        
        # 使用PlaylistModule的generate_and_play_audio方法
        if playlist_module:
            success = playlist_module.generate_and_play_audio()
            if not success:
                self.logger.warning("生成或播放音频失败")
        else:
            self.logger.warning("无法找到播放列表模块")
    
    def _add_main_speech(self):
        """
        添加主话术到队列
        """
        try:
            # 获取音频服务
            audio_service = ServiceLocator.get(IAudioService)
            if not audio_service:
                self.logger.warning("无法获取音频服务，无法添加主话术")
                return
            
            self.logger.info("开始添加主话术到队列")
            
            # 检查主话术管理器是否可用
            if not hasattr(audio_service, 'main_speech_manager') or not audio_service.main_speech_manager:
                self.logger.warning("主话术管理器不可用，无法添加主话术")
                return
            
            # 获取一条主话术
            self.logger.info("从主话术管理器获取随机主话术")
            speech_content = audio_service.main_speech_manager.get_random_speech()
            if not speech_content:
                self.logger.warning("获取主话术失败，无法添加主话术")
                return
            
            self.logger.info(f"获取到主话术: {speech_content}")
            
            # 获取话术文件名
            file_name = audio_service.main_speech_manager.get_speech_file_name(speech_content)
            if not file_name:
                file_name = "未知文件"
                self.logger.warning(f"无法获取话术文件名，使用默认值: {file_name}")
            
            # 创建音频项
            audio_item = AudioItem(
                id=str(uuid.uuid4()),
                file_path="",
                title=speech_content,
                source_type="main_speech",
                metadata={
                    "original_type": "主话术", 
                    "is_temporary": False,
                    "file_name": file_name
                }
            )
            
            # 添加到队列底部
            audio_service.add_to_queue(audio_item)
            
            self.logger.info(f"已添加主话术到队列: {speech_content}")
        except Exception as e:
            self.logger.error(f"添加主话术失败: {str(e)}")
    
    def _play_next(self):
        """
        播放下一个音频
        """
        try:
            # 获取音频服务
            audio_service = ServiceLocator.get(IAudioService)
            if not audio_service:
                self.logger.warning("无法获取音频服务，无法播放下一个")
                return
            
            # 获取队列
            queue = audio_service.get_queue()
            
            # 如果队列不为空
            if queue:
                # 获取第一个项目
                audio_item = queue[0]
                
                # 输出日志
                self.logger.info(f"开始播放: {audio_item.title}")
                
                # 播放项目
                audio_service.play_item(audio_item)
                
                # 注意：不在这里更新状态栏，而是由_on_playback_started方法处理
                # 这样可以确保状态栏的更新与实际播放状态同步
        except Exception as e:
            self.logger.error(f"播放下一个音频失败: {str(e)}")
            # 发生错误时更新状态栏
            self.status_bar.update_playback_status("就绪")
    
    def add_interaction(self, username, content):
        """
        添加用户互动
        
        @param username: 用户名
        @param content: 互动内容
        """
        # 这个方法已经不需要了，由user_panel直接处理
        pass
    
    def add_user_join(self, username, count):
        """
        添加用户进入
        
        @param username: 用户名
        @param count: 进入次数
        """
        # 这个方法已经不需要了，由user_panel直接处理
        pass
    
    def add_to_playlist(self, item_type, content, audio_path=None):
        """
        添加到播放队列
        
        @param item_type: 项目类型
        @param content: 项目内容
        @param audio_path: 音频文件路径，如果为None则使用content作为文本生成语音
        """
        self.playlist_panel.add_to_playlist(item_type, content, audio_path)
    
    def add_playback_log(self, message):
        """
        添加播放日志
        
        @param message: 日志消息
        """
        self.log_panel.add_playback_log(message)
    
    def add_ai_log(self, message):
        """
        添加AI日志
        
        @param message: 日志消息
        """
        self.log_panel.add_ai_log(message)
    
    def add_sync_item(self, speech, video, keyword):
        """
        添加音画同步项目
        
        @param speech: 话术
        @param video: 视频
        @param keyword: 关键词
        """
        self.content_panel.add_sync_item(speech, video, keyword)
    
    def update_connection_status(self, status):
        """
        更新连接状态
        
        @param status: 连接状态
        """
        # 更新状态栏的连接状态
        self.status_bar.update_connection_status(status)
        
        # 不再修改开始按钮的状态和文本
        
    def update_host_status(self, status):
        """
        更新主播状态
        
        @param status: 主播状态
        """
        self.status_bar.update_host_status(status)
    
    def update_playback_status(self, status):
        """
        更新播放状态
        
        @param status: 状态信息
        """
        try:
            # 如果状态栏存在，更新状态
            if hasattr(self, 'status_bar') and self.status_bar:
                # 检查状态栏是否有update_playback_status方法
                if hasattr(self.status_bar, 'update_sync_status'):
                    # 使用update_sync_status方法代替，因为它是状态栏中用于显示状态的通用方法
                    # 参数为"同步状态:播放中"或"同步状态:暂停"等
                    if status == "播放中":
                        self.status_bar.update_sync_status(f"播放中")
                    elif status == "暂停":
                        self.status_bar.update_sync_status(f"已暂停")
                    elif status == "就绪":
                        self.status_bar.update_sync_status(f"就绪")
                    else:
                        self.status_bar.update_sync_status(f"{status}")
                else:
                    self.logger.warning("状态栏没有update_playback_status或update_sync_status方法")
            else:
                self.logger.warning("无法更新播放状态：状态栏不可用")
        except Exception as e:
            self.logger.error(f"更新播放状态时出错: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
    
    def update_audio_service_status(self, status):
        """
        更新音频服务状态 - 仅限于显示连接状态
        
        @param status: 状态文本
        """
        # 过滤掉可能的队列或播放状态信息，只传递连接状态
        valid_states = ["已连接", "未连接", "连接中", "连接错误", "启动失败"]
        if status not in valid_states:
            self.logger.debug(f"跳过非标准音频服务状态更新: {status}")
            return
            
        self.logger.debug(f"更新音频服务状态: {status}")
        self.status_bar.update_audio_service_status(status)
    
    def update_ai_service_status(self, status):
        """
        更新 AI 服务状态 - 仅支持"已连接"和"未连接"两种状态
        
        @param status: 状态文本，应为"已连接"或"未连接"
        """
        # 确保状态值只能是"已连接"或"未连接"
        if status not in ["已连接", "未连接"]:
            self.logger.warning(f"收到非法AI服务状态: {status}，强制转换为'未连接'")
            status = "未连接"
        
        self.logger.debug(f"更新AI服务状态: {status}")
        self.status_bar.update_ai_service_status(status)
        
        # 保存当前AI服务状态到本地变量，以便在需要时恢复
        self._ai_service_status = status
    
    def update_sync_status(self, status):
        """
        更新音画同步状态
        
        @param status: 状态文本
        """
        # 更新状态栏的音画同步状态
        self.status_bar.update_sync_status(status)
    
    def update_playback_info(self, info):
        """
        更新播放信息
        
        @param info: 播放信息
        """
        # 移除对content_panel的调用，现在只记录日志
        self.logger.debug(f"播放信息更新: {info}")
    
    def update_generated_info(self, info):
        """
        更新生成信息
        
        @param info: 生成信息
        """
        # 移除对content_panel的调用，现在只记录日志
        self.logger.debug(f"生成信息更新: {info}")
    
    def update_audio_output_status(self, status):
        """
        更新音频输出状态
        
        @param status: 音频输出状态
        """
        self.status_bar.update_audio_output_status(status)
    
    def update_keyword_status(self, status):
        """
        更新关键词状态
        
        @param status: 关键词状态
        """
        # 根据启用状态添加前缀，状态从配置服务获取
        if self.config_service:
            self.keyword_enabled = self.config_service.get("keyword.enabled", True)
        
        if not self.keyword_enabled:
            status = f"disabled:{status}"
        self.status_bar.update_keyword_status(status)
    
    def update_user_join_status(self, status):
        """
        更新动态欢迎状态
        
        @param status: 状态文本
        """
        # 获取配置服务
        config_service = ServiceLocator.get(IConfigService)
        if config_service:
            # 获取动态欢迎配置
            enabled = config_service.get("flow_welcome.enabled", False)
            period = config_service.get("flow_welcome.period", 30)
            low_threshold = config_service.get("flow_welcome.low_threshold", 10)
            high_threshold = config_service.get("flow_welcome.high_threshold", 50)
            
            # 构建状态显示文本
            status_text = f"{low_threshold}-{high_threshold}人/{period}秒"
            
            # 根据启用状态添加前缀
            if not enabled:
                status_text = f"disabled:{status_text}"
                
            # 更新状态栏显示
            self.status_bar.update_user_join_status(status_text)
            self.logger.debug(f"更新动态欢迎状态: {status_text} (启用={enabled})")
        else:
            self.logger.warning("无法获取配置服务，跳过动态欢迎状态更新")
    
    def _on_audio_will_pause_after_current(self, event):
        """
        处理"播放完当前音频后暂停"事件
        
        @param event: 事件对象
        """
        try:
            # 更新UI状态
            self.is_paused = True
            self.pause_resume_button.setText("继续")
            self.pause_resume_button.setStyleSheet("background-color: #4CAF50; color: white;")  # 设置绿色背景
            
            # 显示提示信息
            self.log_panel.add_playback_log("已设置播放完当前音频后暂停")
            self.logger.info("已接收'播放完当前音频后暂停'事件")
        except Exception as e:
            self.logger.error(f"处理'播放完当前音频后暂停'事件失败: {str(e)}")
        